/*
    * Copyright (C) 2008 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect.testing;
  
  import static com.google.common.collect.testing.Helpers.castOrCopyToList;
  import static com.google.common.collect.testing.Helpers.equal;
  import static com.google.common.collect.testing.Helpers.mapEntry;
  import static java.util.Collections.sort;
  
  import com.google.common.annotations.GwtCompatible;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  import java.util.SortedMap;
  import java.util.SortedSet;
  
  /**
   * Derived suite generators, split out of the suite builders so that they are available to GWT.
   *
   * @author George van den Driessche
   */
  @GwtCompatible
  public final class DerivedCollectionGenerators {
    public static class MapEntrySetGenerator<K, V>
        implements TestSetGenerator<Map.Entry<K, V>>, DerivedGenerator {
      private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
          mapGenerator;
  
      public MapEntrySetGenerator(
          OneSizeTestContainerGenerator<
              Map<K, V>, Map.Entry<K, V>> mapGenerator) {
        this.mapGenerator = mapGenerator;
      }
  
      @Override
      public SampleElements<Map.Entry<K, V>> samples() {
        return mapGenerator.samples();
      }
  
      @Override
      public Set<Map.Entry<K, V>> create(Object... elements) {
        return mapGenerator.create(elements).entrySet();
      }
  
      @Override
      public Map.Entry<K, V>[] createArray(int length) {
        return mapGenerator.createArray(length);
      }
  
      @Override
      public Iterable<Map.Entry<K, V>> order(
          List<Map.Entry<K, V>> insertionOrder) {
        return mapGenerator.order(insertionOrder);
      }
  
      @Override
      public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
        return mapGenerator;
      }
    }
  
    // TODO: investigate some API changes to SampleElements that would tidy up
    // parts of the following classes.
  
    static <K, V> TestSetGenerator<K> keySetGenerator(
        OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> mapGenerator) {
      TestContainerGenerator<Map<K, V>, Entry<K, V>> generator = mapGenerator.getInnerGenerator();
      if (generator instanceof TestSortedMapGenerator
          && ((TestSortedMapGenerator<K, V>) generator).create().keySet() instanceof SortedSet) {
        return new MapSortedKeySetGenerator<K, V>(mapGenerator);
      } else {
        return new MapKeySetGenerator<K, V>(mapGenerator);
      }
    }
  
    public static class MapKeySetGenerator<K, V>
        implements TestSetGenerator<K>, DerivedGenerator {
      private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
         mapGenerator;
     private final SampleElements<K> samples;
 
     public MapKeySetGenerator(
         OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
             mapGenerator) {
       this.mapGenerator = mapGenerator;
       final SampleElements<Map.Entry<K, V>> mapSamples =
           this.mapGenerator.samples();
       this.samples = new SampleElements<K>(
           mapSamples.e0.getKey(),
           mapSamples.e1.getKey(),
           mapSamples.e2.getKey(),
           mapSamples.e3.getKey(),
           mapSamples.e4.getKey());
     }
 
     @Override
     public SampleElements<K> samples() {
       return samples;
     }
 
     @Override
     public Set<K> create(Object... elements) {
       @SuppressWarnings("unchecked")
       K[] keysArray = (K[]) elements;
 
       // Start with a suitably shaped collection of entries
       Collection<Map.Entry<K, V>> originalEntries =
           mapGenerator.getSampleElements(elements.length);
 
       // Create a copy of that, with the desired value for each key
       Collection<Map.Entry<K, V>> entries =
           new ArrayList<Entry<K, V>>(elements.length);
       int i = 0;
       for (Map.Entry<K, V> entry : originalEntries) {
         entries.add(Helpers.mapEntry(keysArray[i++], entry.getValue()));
       }
 
       return mapGenerator.create(entries.toArray()).keySet();
     }
 
     @Override
     public K[] createArray(int length) {
       // TODO: with appropriate refactoring of OneSizeGenerator, we can perhaps
       // tidy this up and get rid of the casts here and in
       // MapValueCollectionGenerator.
 
       return ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator())
           .createKeyArray(length);
     }
 
     @Override
     public Iterable<K> order(List<K> insertionOrder) {
       V v = ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator()).samples().e0.getValue();
       List<Entry<K, V>> entries = new ArrayList<Entry<K, V>>();
       for (K element : insertionOrder) {
         entries.add(mapEntry(element, v));
       }
 
       List<K> keys = new ArrayList<K>();
       for (Entry<K, V> entry : mapGenerator.order(entries)) {
         keys.add(entry.getKey());
       }
       return keys;
     }
 
     @Override
     public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
       return mapGenerator;
     }
   }
   
   public static class MapSortedKeySetGenerator<K, V> extends MapKeySetGenerator<K, V>
       implements TestSortedSetGenerator<K>, DerivedGenerator {
     private final TestSortedMapGenerator<K, V> delegate;
     
     public MapSortedKeySetGenerator(
         OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>> mapGenerator) {
       super(mapGenerator);
       this.delegate = (TestSortedMapGenerator<K, V>) mapGenerator.getInnerGenerator();
     }
 
     @Override
     public SortedSet<K> create(Object... elements) {
       return (SortedSet<K>) super.create(elements);
     }
 
     @Override
     public K belowSamplesLesser() {
       return delegate.belowSamplesLesser().getKey();
     }
 
     @Override
     public K belowSamplesGreater() {
       return delegate.belowSamplesGreater().getKey();
     }
 
     @Override
     public K aboveSamplesLesser() {
       return delegate.aboveSamplesLesser().getKey();
     }
 
     @Override
     public K aboveSamplesGreater() {
       return delegate.aboveSamplesGreater().getKey();
     }
     
   }
 
   public static class MapValueCollectionGenerator<K, V>
       implements TestCollectionGenerator<V>, DerivedGenerator {
     private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
         mapGenerator;
     private final SampleElements<V> samples;
 
     public MapValueCollectionGenerator(
         OneSizeTestContainerGenerator<
             Map<K, V>, Map.Entry<K, V>> mapGenerator) {
       this.mapGenerator = mapGenerator;
       final SampleElements<Map.Entry<K, V>> mapSamples =
           this.mapGenerator.samples();
       this.samples = new SampleElements<V>(
           mapSamples.e0.getValue(),
           mapSamples.e1.getValue(),
           mapSamples.e2.getValue(),
           mapSamples.e3.getValue(),
           mapSamples.e4.getValue());
     }
 
     @Override
     public SampleElements<V> samples() {
       return samples;
     }
 
     @Override
     public Collection<V> create(Object... elements) {
       @SuppressWarnings("unchecked")
       V[] valuesArray = (V[]) elements;
 
       // Start with a suitably shaped collection of entries
       Collection<Map.Entry<K, V>> originalEntries =
           mapGenerator.getSampleElements(elements.length);
 
       // Create a copy of that, with the desired value for each value
       Collection<Map.Entry<K, V>> entries =
           new ArrayList<Entry<K, V>>(elements.length);
       int i = 0;
       for (Map.Entry<K, V> entry : originalEntries) {
         entries.add(Helpers.mapEntry(entry.getKey(), valuesArray[i++]));
       }
 
       return mapGenerator.create(entries.toArray()).values();
     }
 
     @Override
     public V[] createArray(int length) {
       //noinspection UnnecessaryLocalVariable
       final V[] vs = ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator())
           .createValueArray(length);
       return vs;
     }
 
     @Override
     public Iterable<V> order(List<V> insertionOrder) {
       final List<Entry<K, V>> orderedEntries =
           castOrCopyToList(mapGenerator.order(castOrCopyToList(
               mapGenerator.getSampleElements(5))));
       sort(insertionOrder, new Comparator<V>() {
         @Override public int compare(V left, V right) {
           // The indexes are small enough for the subtraction trick to be safe.
           return indexOfEntryWithValue(left) - indexOfEntryWithValue(right);
         }
 
         int indexOfEntryWithValue(V value) {
           for (int i = 0; i < orderedEntries.size(); i++) {
             if (equal(orderedEntries.get(i).getValue(), value)) {
               return i;
             }
           }
           throw new IllegalArgumentException("Map.values generator can order only sample values");
         }
       });
       return insertionOrder;
     }
 
     @Override
     public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
       return mapGenerator;
     }
   }
 
   // TODO(cpovirk): could something like this be used elsewhere, e.g., ReserializedListGenerator?
   static class ForwardingTestMapGenerator<K, V> implements TestMapGenerator<K, V> {
     TestMapGenerator<K, V> delegate;
 
     ForwardingTestMapGenerator(TestMapGenerator<K, V> delegate) {
       this.delegate = delegate;
     }
 
     @Override
     public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
       return delegate.order(insertionOrder);
     }
 
     @Override
     public K[] createKeyArray(int length) {
       return delegate.createKeyArray(length);
     }
 
     @Override
     public V[] createValueArray(int length) {
       return delegate.createValueArray(length);
     }
 
     @Override
     public SampleElements<Entry<K, V>> samples() {
       return delegate.samples();
     }
 
     @Override
     public Map<K, V> create(Object... elements) {
       return delegate.create(elements);
     }
 
     @Override
     public Entry<K, V>[] createArray(int length) {
       return delegate.createArray(length);
     }
   }
 
   /**
    * Two bounds (from and to) define how to build a subMap.
    */
   public enum Bound {
     INCLUSIVE,
     EXCLUSIVE,
     NO_BOUND;
   }
   
   public static class SortedSetSubsetTestSetGenerator<E>
       implements TestSortedSetGenerator<E> {
     final Bound to;
     final Bound from;
     final E firstInclusive;
     final E lastInclusive;
     private final Comparator<? super E> comparator;
     private final TestSortedSetGenerator<E> delegate;
     
     public SortedSetSubsetTestSetGenerator(
         TestSortedSetGenerator<E> delegate, Bound to, Bound from) {
       this.to = to;
       this.from = from;
       this.delegate = delegate;
       
       SortedSet<E> emptySet = delegate.create();
       this.comparator = emptySet.comparator();
       
       SampleElements<E> samples = delegate.samples();
       List<E> samplesList = new ArrayList<E>(samples.asList());
       Collections.sort(samplesList, comparator);
       this.firstInclusive = samplesList.get(0);
       this.lastInclusive = samplesList.get(samplesList.size() - 1);
     }
 
     public final TestSortedSetGenerator<E> getInnerGenerator() {
       return delegate;
     }
 
     public final Bound getTo() {
       return to;
     }
 
     public final Bound getFrom() {
       return from;
     }
 
     @Override
     public SampleElements<E> samples() {
       return delegate.samples();
     }
 
     @Override
     public E[] createArray(int length) {
       return delegate.createArray(length);
     }
 
     @Override
     public Iterable<E> order(List<E> insertionOrder) {
       return delegate.order(insertionOrder);
     }
 
     @Override
     public SortedSet<E> create(Object... elements) {
       @SuppressWarnings("unchecked") // set generators must pass SampleElements values
       List<E> normalValues = (List) Arrays.asList(elements);
       List<E> extremeValues = new ArrayList<E>();
       
       // nulls are usually out of bounds for a subset, so ban them altogether
       for (Object o : elements) {
         if (o == null) {
           throw new NullPointerException();
         }
       }
 
       // prepare extreme values to be filtered out of view
       E firstExclusive = delegate.belowSamplesGreater();
       E lastExclusive = delegate.aboveSamplesLesser();
       if (from != Bound.NO_BOUND) {
         extremeValues.add(delegate.belowSamplesLesser());
         extremeValues.add(delegate.belowSamplesGreater());
       }
       if (to != Bound.NO_BOUND) {
         extremeValues.add(delegate.aboveSamplesLesser());
         extremeValues.add(delegate.aboveSamplesGreater());
       }
 
       // the regular values should be visible after filtering
       List<E> allEntries = new ArrayList<E>();
       allEntries.addAll(extremeValues);
       allEntries.addAll(normalValues);
       SortedSet<E> map = delegate.create(allEntries.toArray());
 
       return createSubSet(map, firstExclusive, lastExclusive);
     }
 
     /**
      * Calls the smallest subSet overload that filters out the extreme values.
      */
     SortedSet<E> createSubSet(SortedSet<E> set, E firstExclusive, E lastExclusive) {
       if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
         return set.headSet(lastExclusive);
       } else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
         return set.tailSet(firstInclusive);
       } else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
         return set.subSet(firstInclusive, lastExclusive);
       } else {
         throw new IllegalArgumentException();
       }
     }
 
     @Override
     public E belowSamplesLesser() {
       throw new UnsupportedOperationException();
     }
 
     @Override
     public E belowSamplesGreater() {
       throw new UnsupportedOperationException();
     }
 
     @Override
     public E aboveSamplesLesser() {
       throw new UnsupportedOperationException();
     }
 
     @Override
     public E aboveSamplesGreater() {
       throw new UnsupportedOperationException();
     }
   }
 
   /*
    * TODO(cpovirk): surely we can find a less ugly solution than a class that accepts 3 parameters,
    * exposes as many getters, does work in the constructor, and has both a superclass and a subclass
    */
   public static class SortedMapSubmapTestMapGenerator<K, V>
       extends ForwardingTestMapGenerator<K, V> implements TestSortedMapGenerator<K, V> {
     final Bound to;
     final Bound from;
     final K firstInclusive;
     final K lastInclusive;
     private final Comparator<Entry<K, V>> entryComparator;
 
     public SortedMapSubmapTestMapGenerator(
         TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
       super(delegate);
       this.to = to;
       this.from = from;
 
       SortedMap<K, V> emptyMap = delegate.create();
       this.entryComparator = Helpers.entryComparator(emptyMap.comparator());
 
       // derive values for inclusive filtering from the input samples
       SampleElements<Entry<K, V>> samples = delegate.samples();
       @SuppressWarnings("unchecked") // no elements are inserted into the array
       List<Entry<K, V>> samplesList = Arrays.asList(
           samples.e0, samples.e1, samples.e2, samples.e3, samples.e4);
       Collections.sort(samplesList, entryComparator);
       this.firstInclusive = samplesList.get(0).getKey();
       this.lastInclusive = samplesList.get(samplesList.size() - 1).getKey();
     }
 
     @Override public SortedMap<K, V> create(Object... entries) {
       @SuppressWarnings("unchecked") // map generators must past entry objects
       List<Entry<K, V>> normalValues = (List) Arrays.asList(entries);
       List<Entry<K, V>> extremeValues = new ArrayList<Entry<K, V>>();
 
       // prepare extreme values to be filtered out of view
       K firstExclusive = getInnerGenerator().belowSamplesGreater().getKey();
       K lastExclusive = getInnerGenerator().aboveSamplesLesser().getKey();
       if (from != Bound.NO_BOUND) {
         extremeValues.add(getInnerGenerator().belowSamplesLesser());
         extremeValues.add(getInnerGenerator().belowSamplesGreater());
       }
       if (to != Bound.NO_BOUND) {
         extremeValues.add(getInnerGenerator().aboveSamplesLesser());
         extremeValues.add(getInnerGenerator().aboveSamplesGreater());
       }
 
       // the regular values should be visible after filtering
       List<Entry<K, V>> allEntries = new ArrayList<Entry<K, V>>();
       allEntries.addAll(extremeValues);
       allEntries.addAll(normalValues);
       SortedMap<K, V> map = (SortedMap<K, V>)
           delegate.create((Object[])
               allEntries.toArray(new Entry<?, ?>[allEntries.size()]));
 
       return createSubMap(map, firstExclusive, lastExclusive);
     }
 
     /**
      * Calls the smallest subMap overload that filters out the extreme values. This method is
      * overridden in NavigableMapTestSuiteBuilder.
      */
     SortedMap<K, V> createSubMap(SortedMap<K, V> map, K firstExclusive, K lastExclusive) {
       if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
         return map.headMap(lastExclusive);
       } else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
         return map.tailMap(firstInclusive);
       } else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
         return map.subMap(firstInclusive, lastExclusive);
       } else {
         throw new IllegalArgumentException();
       }
     }
 
     public final Bound getTo() {
       return to;
     }
 
     public final Bound getFrom() {
       return from;
     }
 
     public final TestSortedMapGenerator<K, V> getInnerGenerator() {
       return (TestSortedMapGenerator<K, V>) delegate;
     }
 
     @Override
     public Entry<K, V> belowSamplesLesser() {
       // should never reach here!
       throw new UnsupportedOperationException();
     }
 
     @Override
     public Entry<K, V> belowSamplesGreater() {
       // should never reach here!
       throw new UnsupportedOperationException();
     }
 
     @Override
     public Entry<K, V> aboveSamplesLesser() {
       // should never reach here!
       throw new UnsupportedOperationException();
     }
 
     @Override
     public Entry<K, V> aboveSamplesGreater() {
       // should never reach here!
       throw new UnsupportedOperationException();
     }
   }
 
   private DerivedCollectionGenerators() {}
 }